package jzlb

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

// 按照条件 和 非条件 分割  被' '包裹的 不会被分割 如果 ”内有'  可以用 " \\' "  或者是 ` \' `
func t_条件分割_带原条件(原始文本 string, 条件组 []string) (返回_值 []string) {
	分段文本 := strings.Split(原始文本, "")
	组文本 := ""
	截断 := false
	要执行 := false
	for i, v := range 分段文本 {
		组文本 = 组文本 + v

		if v == "'" {

			截断 = !截断
			要执行 = true
			if i > 0 && 分段文本[i-1] == `\` {
				截断 = !截断
				要执行 = false
			}

		}
		if 截断 && 要执行 {
			要执行 = false
			组文本 = 组文本[:len(组文本)-1]
			文本 := 条件加空格(组文本, 条件组, 条件组)
			当前组 := strings.Fields(文本)
			返回_值 = append(返回_值, 当前组...)
			组文本 = "'"
		} else if !截断 && 要执行 {
			要执行 = false
			返回_值 = append(返回_值, 组文本)
			组文本 = ""

		}

	}
	if len(组文本) > 0 {
		文本 := 条件加空格(组文本, 条件组, 条件组)
		当前组 := strings.Fields(文本)
		返回_值 = append(返回_值, 当前组...)

	}
	for i, v := range 返回_值 {
		返回_值[i] = strings.Replace(v, `\'`, "'", -1)

	}
	return
}
func 条件加空格(原始文本 string, 条件组, 参照组 []string) (返回值 string) {
	条件数 := len(条件组)
	if 条件数 == 0 {
		return
	}
	条件值 := 条件组[0]
	if 条件数 == 1 {
		分割组 := strings.Split(原始文本, 条件值)
		组数 := len(分割组)
		当前组 := make([]string, 0)

		for i, v := range 分割组 {
			if i == 组数-1 {
				当前组 = append(当前组, v)

			} else {
				当前组 = append(当前组, v, 条件值)
			}

		}
		返回值 = strings.Join(当前组, " ")
		return
	}

	分割组 := strings.Split(原始文本, 条件值)
	组数 := len(分割组)
	当前组 := make([]string, 0)

	for i, v := range 分割组 {
		if i == 组数-1 {
			当前组 = append(当前组, v)

		} else {
			当前组 = append(当前组, v, 条件值)
		}

	}
	for i, v := range 当前组 {
		重复 := false
		for _, X := range 参照组 {
			if X == v {
				重复 = true
				break
			}
		}
		if !重复 {
			当前组[i] = 条件加空格(v, 条件组[1:], 参照组)
		}
	}
	返回值 = strings.Join(当前组, " ")

	return
}

// 判断 数组里 ( 和 ) 的成对 位置越前的越有括号优先级 并返回 括号顺序的 位置数组
func k_数组里括号位置算法(条件组 []string) (返回位置组 [][]int, 返回_错误 error) {
	返回位置组, 返回_错误 = 括号位置算法(条件组, -1)
	if 返回_错误 != nil {
		return
	}
	存在 := false
	for i, v := range 条件组 {
		if v == ")" {
			存在 = false
			for _, 位置 := range 返回位置组 {
				if i == 位置[1] {
					存在 = true
				}
			}
			if !存在 {
				返回_错误 = errors.New("错误:括号不对称,多了 ) 号")
				return
			}
		}

	}
	return
}

func 括号位置算法(条件组 []string, 左开始位置 int) (返回位置组 [][]int, 返回_错误 error) {
	开始括号位置 := -1
	开始括号数 := 0
	//结束括号位置 := -1
	结束括号数 := 0
	for i, v := range 条件组 {

		if 开始括号位置 == -1 && v == "(" {
			if i > 左开始位置 {
				开始括号位置 = i
				开始括号数++
			}
		} else if 开始括号位置 != -1 && v == "(" {
			if i > 左开始位置 {
				开始括号数++
			}
		} else if 开始括号位置 != -1 && v == ")" {
			if i > 左开始位置 {
				结束括号数++
			}
			if 开始括号数 == 结束括号数 {
				括号位置组 := []int{开始括号位置, i}
				返回位置组, 返回_错误 = 括号位置算法(条件组, 开始括号位置)
				返回位置组 = append(返回位置组, 括号位置组)
				return

			}

		}
		// else if 开始括号位置 != -1 && v == ")" && i> 左开始位置{
		// 	fmt.Println(99999,i,左开始位置,v)
		// 	//右括号存在=true
		// }

	}

	if 开始括号数 != 结束括号数 {

		返回_错误 = errors.New("错误:括号不对称,少了 ) 号")
		return

	}

	//fmt.Println("开始括号数,结束括号数", 开始括号数, 结束括号数)
	return
}

// 不够  健壮 下面有健壮的
func s_顺序运算加减乘除数组(条件组 []string) (返回_结果组 []string, 返回_错误 error) {
	fmt.Println(1, 条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {
		if v == "*" || v == "/" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误")
				return
			}
			左, err := strconv.ParseFloat(条件组[i-1], 64)
			if err != nil {
				返回_错误 = err
				return
			}
			右, err := strconv.ParseFloat(条件组[i+1], 64)
			if err != nil {
				返回_错误 = err
				return
			}
			值 := 0.0
			if v == "*" {
				值 = 左 * 右
			} else {
				值 = 左 / 右
			}

			if i <= 1 && i >= 组长-2 {
				新组 := []string{fmt.Sprintf("%v", 值)}
				返回_结果组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				返回_结果组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			}
			if len(返回_结果组) == 3 {
				if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
					新组 := make([]string, 0)
					新组 = append(新组, 返回_结果组[1])
					返回_结果组 = 新组
				}
			}
			返回_结果组, 返回_错误 = s_顺序运算加减乘除数组(返回_结果组)
			return
		}

	}

	for i, v := range 条件组 {
		if v == "+" || v == "-" {
			if i == 0 {
				if v == "-" && 组长 >= 2 {
					新组 := make([]string, 0)
					值 := v + 条件组[1]
					新组 = append(新组, 值)
					if 组长 >= 3 {
						新组 = append(新组, 条件组[i+2:]...)
					}
					返回_结果组 = 新组
					if len(返回_结果组) == 3 {

						if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
							新组 := make([]string, 0)
							新组 = append(新组, 返回_结果组[1])
							返回_结果组 = 新组
							return
						}

					}

					返回_结果组, 返回_错误 = s_顺序运算加减乘除数组(返回_结果组)
					return

				}
				返回_错误 = errors.New("错误: * 位置错误1")
				return
			}
			if i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误2")
				return
			}
			左, err1 := strconv.ParseFloat(条件组[i-1], 64)

			右, err2 := strconv.ParseFloat(条件组[i+1], 64)
			值 := ""
			if v == "+" {
				if (strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'")) || (strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'")) {
					值 = 条件组[i-1] + 条件组[i+1]
					值 = strings.Replace(值, "'", "", -1)
				} else if err1 != nil || err2 != nil {
					值 = 条件组[i-1] + 条件组[i+1]

				} else {
					值 = fmt.Sprintf("%v", 左+右)
				}

			} else {
				if err2 != nil {
					返回_错误 = errors.New("错误: - 计算类型错误3")
					return
				} else if err1 != nil {
					新组 := make([]string, 0)
					值 := v + 条件组[i+1]
					新组 = append(新组, 条件组[:i]...)
					新组 = append(新组, 值)
					if 组长 >= i+3 {
						新组 = append(新组, 条件组[i+2:]...)
					}
					返回_结果组 = 新组
					if len(返回_结果组) == 3 {

						if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
							新组 := make([]string, 0)
							新组 = append(新组, 返回_结果组[1])
							返回_结果组 = 新组
							return
						}

					}

					返回_结果组, 返回_错误 = s_顺序运算加减乘除数组(返回_结果组)
					return

				}

				值 = fmt.Sprintf("%v", 左-右)

			}
			if i <= 1 && i >= 组长-2 {
				新组 := []string{值}
				返回_结果组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				返回_结果组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			}
			if len(返回_结果组) == 3 {

				if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
					新组 := make([]string, 0)
					新组 = append(新组, 返回_结果组[1])
					返回_结果组 = 新组
					return
				}
			}
			返回_结果组, 返回_错误 = s_顺序运算加减乘除数组(返回_结果组)
			return
		}
	}

	返回_结果组 = 条件组
	if len(返回_结果组) == 3 {

		if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
			新组 := make([]string, 0)
			新组 = append(新组, 返回_结果组[1])
			返回_结果组 = 新组
			return
		}
	}
	return
}

// 可以将 带有 ()+-*/ 数字 文本  和其他符号的 文本  分割后成数组后 拿进来用  会自动 计算 里面的 +-*/ 并 按优先级处理掉括号
func s_顺序运算加减乘除数组_健壮(条件组 []string) (返回_结果组 []string, 返回_错误 error) {
	//fmt.Println(1, 条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {
		if v == "*" || v == "/" || v == "%" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误")
				return
			}
			左, err1 := strconv.ParseFloat(条件组[i-1], 64)
			右, err2 := strconv.ParseFloat(条件组[i+1], 64)
			if err1 != nil && err2 != nil {
				if 条件组[i-1] == ")" && 条件组[i+1] == "(" {

				} else {
					返回_错误 = errors.New("错误: 符号" + v + " 计算类型错误")
					return

				}

			} else if err1 == nil && err2 == nil {
				值 := 0.0
				if v == "*" {
					值 = 左 * 右
				} else if v == "/" {
					值 = 左 / 右
				} else {
					值 = float64(int(左) % int(右))
				}

				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_结果组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_结果组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_结果组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_结果组 = 新组
				}

				if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {

					if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_结果组[:i-2]...)
						新组 = append(新组, 返回_结果组[i-1])
						if i+1 <= len(返回_结果组) {
							新组 = append(新组, 返回_结果组[i+1:]...)
						}

						返回_结果组 = 新组
					}
				}
				返回_结果组, 返回_错误 = s_顺序运算加减乘除数组_健壮(返回_结果组)
				return

			}

		}

	}

	for i, v := range 条件组 {
		if v == "+" || v == "-" {
			if i == 0 {
				if v == "-" && 组长 >= 2 {
					新组 := make([]string, 0)
					值 := v + 条件组[1]
					新组 = append(新组, 值)
					if 组长 >= 3 {
						新组 = append(新组, 条件组[i+2:]...)
					}
					返回_结果组 = 新组
					if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {
						if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {

							新组 := make([]string, 0)
							新组 = append(新组, 返回_结果组[:i-2]...)
							新组 = append(新组, 返回_结果组[i-1])
							if i+1 <= len(返回_结果组) {
								新组 = append(新组, 返回_结果组[i+1:]...)
							}

							返回_结果组 = 新组
						}
					}

					返回_结果组, 返回_错误 = s_顺序运算加减乘除数组_健壮(返回_结果组)
					return

				}
				返回_错误 = errors.New("错误: * 位置错误1")
				return
			}
			if i == 组长 {
				返回_错误 = errors.New("错误: * 位置错误2")
				return
			}

			左, err1 := strconv.ParseFloat(条件组[i-1], 64)

			右, err2 := strconv.ParseFloat(条件组[i+1], 64)
			值 := ""
			if err1 != nil && err2 != nil {
				if v == "+" && strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'") && strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'") {
					值 = 条件组[i-1][:len(条件组[i-1])-1] + 条件组[i+1][1:len(条件组[i+1])]
					// 值 = 条件组[i-1] + 条件组[i+1]
					// 值 = strings.Replace(值, "'", "", -1)
					// 值 = "'" + 值 + "'"
				} else if 条件组[i-1] == ")" && 条件组[i+1] == "(" {
					continue

				} else if v == "-" && 条件组[i+1] == "(" {
					continue
				} else {
					返回_错误 = errors.New("错误: 符号" + v + " 计算类型错误")
					return
				}

			} else if err1 == nil && err2 == nil {

				if v == "+" {
					值 = fmt.Sprintf("%v", 左+右)
				} else {
					值 = fmt.Sprintf("%v", 左-右)
				}
			} else if err1 != nil && err2 == nil && v == "-" {
				新组 := make([]string, 0)
				值内 := v + 条件组[i+1]
				新组 = append(新组, 条件组[:i]...)
				新组 = append(新组, 值内)
				if 组长 >= i+3 {
					新组 = append(新组, 条件组[i+2:]...)
				}
				返回_结果组 = 新组
				if len(返回_结果组) >= 3 && i >= 1 && i+2 <= len(返回_结果组) {

					if 返回_结果组[i-1] == "(" && 返回_结果组[i+1] == ")" {

						新组 := make([]string, 0)
						新组 = append(新组, 返回_结果组[:i-1]...)
						新组 = append(新组, 返回_结果组[i])
						if i+2 <= len(返回_结果组) {
							新组 = append(新组, 返回_结果组[i+2:]...)
						}

						返回_结果组 = 新组

					}
				}

				返回_结果组, 返回_错误 = s_顺序运算加减乘除数组_健壮(返回_结果组)
				return

			} else if (err1 == nil || err2 == nil) && v == "+" {
				if (strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'")) || (strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'")) {
					值1 := ""
					值2 := ""
					if strings.HasPrefix(条件组[i-1], "'") && strings.HasSuffix(条件组[i-1], "'") {
						值1 = 条件组[i-1][:len(条件组[i-1])-1]
					} else {
						值1 = "'" + 条件组[i-1]
					}
					if strings.HasPrefix(条件组[i+1], "'") && strings.HasSuffix(条件组[i+1], "'") {
						值2 = 条件组[i+1][1:len(条件组[i+1])]
					} else {
						值2 = 条件组[i+1] + "'"
					}
					值 = 值1 + 值2
				} else {
					continue
				}
			} else {

				continue
			}

			if i <= 1 && i >= 组长-2 {
				新组 := []string{值}
				返回_结果组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				返回_结果组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, 值)
				新组 = append(新组, 条件组[i+2:]...)
				返回_结果组 = 新组
			}
			if len(返回_结果组) >= 3 && i >= 2 && i+1 <= len(返回_结果组) {

				if 返回_结果组[i-2] == "(" && 返回_结果组[i] == ")" {
					新组 := make([]string, 0)
					新组 = append(新组, 返回_结果组[:i-2]...)
					新组 = append(新组, 返回_结果组[i-1])
					if i+1 <= len(返回_结果组) {
						新组 = append(新组, 返回_结果组[i+1:]...)
					}

					返回_结果组 = 新组
				}
			}

			返回_结果组, 返回_错误 = s_顺序运算加减乘除数组_健壮(返回_结果组)
			return
		}
	}

	返回_结果组 = 条件组
	if len(返回_结果组) == 3 {

		if 返回_结果组[0] == "(" && 返回_结果组[2] == ")" {
			新组 := make([]string, 0)
			新组 = append(新组, 返回_结果组[1])
			返回_结果组 = 新组
			return
		}
	}
	return
}

// 可以 用 sql 条件语句 判断 map 是否 符合查询条件 返回逻辑值
func m_map查询条件判断(条件语句 string, 被查询map map[string]any) (返回_值 bool, 返回_错误 error) {
	// 返回切片 := strings.Split(条件语句, " ")
	// for i, v := range 返回切片 {
	// 	if v == "and" || v == "ADN" {
	// 		返回切片[i] = "&&"

	// 	} else if v == "or" || v == "OR" {
	// 		返回切片[i] = "||"
	// 	} else if v == "NO LIKE" || v == "not like" {
	// 		返回切片[i] = "~="
	// 	} else if v == "TLIKE" || v == "like" {
	// 		返回切片[i] = "!~="
	// 	}

	// }
	//条件语句 = strings.Join(返回切片, " ")
	分割条件 := []string{"||", "&&", "(", ")", "!~=", "~=", "<=", ">=", "!=", "=", "+", "-", "*", "/", "%", ">", "<"}
	条件切片 := t_条件分割_带原条件(条件语句, 分割条件)
	//fmt.Println("条件切片", 条件切片)
	for i, v := range 条件切片 {
		if v == "and" || v == "ADN" {
			条件切片[i] = "&&"

		} else if v == "or" || v == "OR" {
			条件切片[i] = "||"
		} else if v == "NOTLIKE" || v == "notlike" {
			条件切片[i] = "!~="
		} else if v == "LIKE" || v == "like" {
			条件切片[i] = "~="
		}

	}
	//fmt.Println("条件切片", 条件切片)
	纯在 := false
	for i, v := range 条件切片 {
		if strings.HasPrefix(v, "'") && strings.HasSuffix(v, "'") {
			continue
		}
		_, err := strconv.ParseFloat(v, 64)
		if err == nil {
			continue
		}

		纯在 = false
		for _, vv := range 分割条件 {
			if v == vv {
				纯在 = true
				break
			}
		}
		if 纯在 {
			continue
		}
		结果, ok := 被查询map[v]
		if !ok {
			返回_错误 = errors.New("错误: " + v + " 不存在")
			return
		}
		文本 := any_到文本(结果)
		_, err1 := strconv.ParseFloat(文本, 64)
		if err1 == nil {
			条件切片[i] = 文本
		} else {
			条件切片[i] = "'" + 文本 + "'"
		}
	}
	//fmt.Println(条件切片)
	结果切片, err := s_顺序运算加减乘除数组_健壮(条件切片)
	if err != nil {
		返回_错误 = err
		return
	}
	//fmt.Println(结果切片)
	_, err2 := k_数组里括号位置算法(结果切片)
	if err2 != nil {
		返回_错误 = err2
		return
	}
	//fmt.Println(返回位置组)

	for _, v := range 结果切片 {
		if v == "+" || v == "-" || v == "*" || v == "/" || v == "%" {
			返回_错误 = errors.New("错误:运算符 " + v + " 残余错误")
			return
		}

	}
	逻辑切片, err3 := t_条件数组等式转换逻辑组(结果切片)
	if err3 != nil {
		返回_错误 = err3
		return
	}
	//fmt.Println(逻辑切片)
	结果组, err4 := t_文本逻辑组求得逻辑值(逻辑切片)
	if err4 != nil {
		返回_错误 = err4
		return
	}
	//fmt.Println("最后结果",结果组)
	// if len(结果组) != 1 {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }
	// if 结果组[0] != "true" && 结果组[0] != "false" {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }

	返回_值, 返回_错误 = strconv.ParseBool(结果组[0])
	return
}

// 条件数组内 有 独立的  = > < >= <= !=  ~= !~=  符合两边有 文本或者数值  会判断 并用 文本型的 ture 或者 false 替换掉
func t_条件数组等式转换逻辑组(条件组 []string) (返回_组 []string, 返回_错误 error) {
	//fmt.Println(条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {
		if v == "=" || v == ">" || v == ">=" || v == "<" || v == "<=" || v == "!=" || v == "~=" || v == "!~=" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			_, err1 := strconv.ParseFloat(条件组[i-1], 64)
			if err1 != nil && !strings.HasPrefix(条件组[i-1], "'") && !strings.HasSuffix(条件组[i-1], "'") {
				返回_错误 = errors.New("错误:判断符 " + 条件组[i-1] + v + " 错误")
				return
			}
			_, err2 := strconv.ParseFloat(条件组[i+1], 64)
			if err2 != nil && !strings.HasPrefix(条件组[i+1], "'") && !strings.HasSuffix(条件组[i+1], "'") {
				返回_错误 = errors.New("错误:判断符 " + 条件组[i+1] + v + " 错误")
				return
			}

			值 := d_等式算法(条件组[i-1], v, 条件组[i+1])

			if i <= 1 && i >= 组长-2 {
				新组 := []string{fmt.Sprintf("%v", 值)}
				返回_组 = 新组
			} else if i <= 1 {
				新组 := make([]string, 0)

				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_组 = 新组
			} else if i >= 组长-2 {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				返回_组 = 新组
			} else {
				新组 := make([]string, 0)
				新组 = append(新组, 条件组[:i-1]...)
				新组 = append(新组, fmt.Sprintf("%v", 值))
				新组 = append(新组, 条件组[i+2:]...)
				返回_组 = 新组
			}
			返回_组, 返回_错误 = t_条件数组等式转换逻辑组(返回_组)
			return

		}

	}
	返回_组 = 条件组
	return
}

// 以 原始文本 的数据类型为基准  进行类型转换->判断文本或数值比较    若类型转换失败 则以文本类型判断
// 如 "原始文本" = "判断文本"  返回判断结果
// 支持  = > < >= <= !=  ~= !~=
func d_等式算法(原始文本, 判断符, 判断文本 string) (返回_值 bool) {

	if 判断符 == "=" {
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				返回_值 = 原始文本 == 判断文本
				return
			} else {
				返回_值 = 原始文本 == ("'" + 判断文本 + "'")
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 == 新值
				// 数值2, err := strconv.ParseFloat(新值, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 ==新值
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 == 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 == 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 == 数值2

				return
			}
		}

	} else if 判断符 == "!=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				返回_值 = 原始文本 != 判断文本
				return
			} else {
				返回_值 = 原始文本 != ("'" + 判断文本 + "'")
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 != 新值
				// 数值2, err := strconv.ParseFloat(新值, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 !=新值
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 != 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 == 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 == 数值2

				//返回_值 = 原始文本 != 判断文本
				return
			}
		}
	} else if 判断符 == ">" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 > 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 > 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 > 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 > 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 > 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 > 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 > 数值2
				return
			}
		}
	} else if 判断符 == "<" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 < 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 < 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 < 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 < 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 < 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 < 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 < 数值2
				return
			}
		}
	} else if 判断符 == "<=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 <= 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 <= 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 <= 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 <= 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 <= 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 <= 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 <= 数值2
				return
			}
		}
	} else if 判断符 == ">=" {

		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 := 原始文本[1 : len(原始文本)-1]
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 新值1 >= 新值2
				return
			} else {
				新值1 := 原始文本[1 : len(原始文本)-1]
				返回_值 = 新值1 >= 判断文本
				return
			}

		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值2 := 判断文本[1 : len(判断文本)-1]
				返回_值 = 原始文本 >= 新值2
				// 数值2, err := strconv.ParseFloat(新值2, 64)
				// if err != nil {
				// 	返回_值 = 原始文本 >= 新值2
				// 	return
				// }
				// 数值1, _ := strconv.ParseFloat(原始文本, 64)
				// 返回_值 = 数值1 >= 数值2
				return
			} else {
				新值2 := 判断文本
				数值2, err := strconv.ParseFloat(新值2, 64)
				if err != nil {
					返回_值 = 原始文本 >= 新值2
					return
				}
				数值1, _ := strconv.ParseFloat(原始文本, 64)
				返回_值 = 数值1 >= 数值2
				return
			}
		}
	} else if 判断符 == "~=" {
		新值1 := ""
		新值2 := ""
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本
			}
		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本
				新值2 = 判断文本
			}
		}

		if 新值1 == "" && 新值2 == "" {
			返回_值 = true
			return
		} else if 新值2 == "" {
			返回_值 = false
			return
		}
		if strings.HasPrefix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.HasSuffix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = strings.HasPrefix(新值1, 返回切片[0])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.ContainsAny(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			fmt.Println(666, 返回切片, len(返回切片))
			if len(返回切片) == 2 {
				返回_值 = strings.HasPrefix(新值1, 返回切片[0]) && strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = true
				return
			} else {
				返回_值 = false
				return
			}

		} else {
			返回_值 = strings.Index(新值1, 新值2) > -1
			//返回_值 = strings.ContainsAny(新值1, 新值2)
			return
		}

	} else if 判断符 == "!~=" {
		新值1 := ""
		新值2 := ""
		if strings.HasPrefix(原始文本, "'") && strings.HasSuffix(原始文本, "'") {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本[1 : len(原始文本)-1]
				新值2 = 判断文本
			}
		} else {
			if strings.HasPrefix(判断文本, "'") && strings.HasSuffix(判断文本, "'") {
				新值1 = 原始文本
				新值2 = 判断文本[1 : len(判断文本)-1]
			} else {
				新值1 = 原始文本
				新值2 = 判断文本
			}
		}

		if 新值1 == "" && 新值2 == "" {
			返回_值 = false
			return
		} else if 新值2 == "" {
			返回_值 = false
			return
		}
		if strings.HasPrefix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !strings.HasSuffix(新值1, 返回切片[1])
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.HasSuffix(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !strings.HasPrefix(新值1, 返回切片[0])
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else if strings.ContainsAny(新值2, "%") {
			返回切片 := strings.Split(新值2, "%")
			if len(返回切片) == 2 {
				返回_值 = !(strings.HasPrefix(新值1, 返回切片[0]) && strings.HasSuffix(新值1, 返回切片[1]))
				return
			} else if len(返回切片) == 0 {
				返回_值 = false
				return
			} else {
				返回_值 = false
				return
			}

		} else {
			返回_值 = strings.Index(新值1, 新值2) <= -1
			//返回_值 = !strings.ContainsAny(新值1, 新值2)
			return
		}

	}
	return
}

// 如 [( false !! true ) && true] 这样的文本数组  最后会自动 计算 并返回 [true]  这样的文件结果数组 ,,,返回值 有  [true]  [false]
func t_文本逻辑组求得逻辑值(条件组 []string) (返回_组 []string, 返回_错误 error) {
	//fmt.Println(条件组)
	组长 := len(条件组)
	for i, v := range 条件组 {

		if v == "&&" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			if (条件组[i-1] == "true" || 条件组[i-1] == "false") && (条件组[i+1] == "true" || 条件组[i+1] == "false") {

				值1, err1 := strconv.ParseBool(条件组[i-1])
				if err1 != nil {
					err1 = 返回_错误
					return
				}
				值2, err2 := strconv.ParseBool(条件组[i+1])
				if err2 != nil {
					err1 = 返回_错误
					return
				}
				值 := 值1 && 值2
				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				}
				if len(返回_组) >= 3 && i >= 2 && i+1 <= len(返回_组) {

					if 返回_组[i-2] == "(" && 返回_组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_组[:i-2]...)
						新组 = append(新组, 返回_组[i-1])
						if i+1 <= len(返回_组) {
							新组 = append(新组, 返回_组[i+1:]...)
						}

						返回_组 = 新组
					}
				}

				返回_组, 返回_错误 = t_文本逻辑组求得逻辑值(返回_组)
				return

			}

		}

	}

	for i, v := range 条件组 {

		if v == "||" {
			if i == 0 || i == 组长 {
				返回_错误 = errors.New("错误:不能以 " + v + " 开头结尾 位置错误")
				return
			}
			if (条件组[i-1] == "true" || 条件组[i-1] == "false") && (条件组[i+1] == "true" || 条件组[i+1] == "false") {

				值1, err1 := strconv.ParseBool(条件组[i-1])
				if err1 != nil {
					err1 = 返回_错误
					return
				}
				值2, err2 := strconv.ParseBool(条件组[i+1])
				if err2 != nil {
					err1 = 返回_错误
					return
				}
				值 := 值1 || 值2
				if i <= 1 && i >= 组长-2 {
					新组 := []string{fmt.Sprintf("%v", 值)}
					返回_组 = 新组
				} else if i <= 1 {
					新组 := make([]string, 0)

					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				} else if i >= 组长-2 {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					返回_组 = 新组
				} else {
					新组 := make([]string, 0)
					新组 = append(新组, 条件组[:i-1]...)
					新组 = append(新组, fmt.Sprintf("%v", 值))
					新组 = append(新组, 条件组[i+2:]...)
					返回_组 = 新组
				}
				if len(返回_组) >= 3 && i >= 2 && i+1 <= len(返回_组) {

					if 返回_组[i-2] == "(" && 返回_组[i] == ")" {
						新组 := make([]string, 0)
						新组 = append(新组, 返回_组[:i-2]...)
						新组 = append(新组, 返回_组[i-1])
						if i+1 <= len(返回_组) {
							新组 = append(新组, 返回_组[i+1:]...)
						}

						返回_组 = 新组
					}
				}

				返回_组, 返回_错误 = t_文本逻辑组求得逻辑值(返回_组)
				return

			}

		}

	}
	返回_组 = 条件组
	//fmt.Println("最后结果",结果组)
	if len(返回_组) != 1 {
		返回_错误 = errors.New("错误:查询语法错误")
		return
	}
	if 返回_组[0] != "true" && 返回_组[0] != "false" {
		返回_错误 = errors.New("错误:查询语法错误")
		return
	}

	return
}

// 列表 内部用
func m_map查询_带参数(分割条件, 条件切片 []string, 被查询map map[string]any) (返回_值 bool, 返回_错误 error) {
	返回_值 = false
	纯在 := false

	for i, v := range 条件切片 {
		if strings.HasPrefix(v, "'") && strings.HasSuffix(v, "'") {

			continue
		}
		_, err := strconv.ParseFloat(v, 64)
		if err == nil {

			continue
		}

		纯在 = false
		for _, vv := range 分割条件 {
			if v == vv {
				纯在 = true
				break
			}
		}
		if 纯在 {

			continue
		}

		结果, ok := 被查询map[v]

		if !ok {
			//返回_错误 = errors.New("错误: " + v + " 不存在")
			return
		}
		文本 := any_到文本(结果)
		_, err1 := strconv.ParseFloat(文本, 64)
		if err1 == nil {
			条件切片[i] = 文本
		} else {
			条件切片[i] = "'" + 文本 + "'"
		}
	}

	//fmt.Println(条件切片)
	结果切片, err := s_顺序运算加减乘除数组_健壮(条件切片)
	if err != nil {
		返回_错误 = err
		return
	}
	//fmt.Println(结果切片)
	_, err2 := k_数组里括号位置算法(结果切片)
	if err2 != nil {
		返回_错误 = err2
		return
	}
	//fmt.Println(返回位置组)

	for _, v := range 结果切片 {
		if v == "+" || v == "-" || v == "*" || v == "/" || v == "%" {
			返回_错误 = errors.New("错误:运算符 " + v + " 残余错误")
			return
		}

	}
	逻辑切片, err3 := t_条件数组等式转换逻辑组(结果切片)
	if err3 != nil {
		返回_错误 = err3
		return
	}
	//fmt.Println(逻辑切片)
	结果组, err4 := t_文本逻辑组求得逻辑值(逻辑切片)
	if err4 != nil {
		返回_错误 = err4
		return
	}
	// //fmt.Println("最后结果",结果组)
	// if len(结果组) != 1 {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }
	// if 结果组[0] != "true" && 结果组[0] != "false" {
	// 	返回_错误 = errors.New("错误:查询语法错误")
	// 	return
	// }

	返回_值, 返回_错误 = strconv.ParseBool(结果组[0])
	return
}
